1. Field of the Invention
This invention relates in general to computer implemented random reliability engines, and in particular to a random reliability engine for executing test cases created using a graphical user interface (GUI) driver to test a distributed environment.
2. Description of Related Art
Increasingly, users are working in distributed computer environments. In some distributed computer environments, users at different computers that are connected by a network are able to share applications. In the following example, two computers are connected to each other by a network. A user at one of the computers invokes a word processing application. The output of the word processing application is displayed on the display device of each connected computer. The users at each connected computer can provide input to the word processing application and view the output of the word processing application at that computer, thereby sharing the application.
Typically, unit tests are performed to test parts of a computer environment. However, these unit tests are not adequate for testing distributed computer environments. Currently, there is a need for methods of testing distributed computer environments.
Object oriented programming (OOP) is increasingly used to develop complex applications. OOP is a process of developing computer software using objects. An object is a software package that contains both data and a collection of related structures and procedures. An object is a single instance of a class of objects. A class of objects can be viewed as a blueprint, from which many objects can be formed. OOP allows creation of an object that "depends from" another object. The object that depends from another object inherits all of the aspects of that object. The inherited characteristics can be overridden. Also, the object that depends from another object may have the same underlying functions associated with them, but these functions may have different implementations.
As OOP moves toward the mainstream of software design and development, methods of testing distributed environments should be adapted to make use of the benefits of OOP. A need exists for these principles of OOP to be applied to testing distributed environments such that a set of OOP classes and objects for testing distributed environments can be provided.
Additionally, frameworks are being increasingly used. A framework is a generic application that displays user interface elements, such as windows and dialog boxes, and that supports various functions, such as copy and paste. The framework code provides event handling and flow of control. Moreover, a framework is typically a collection of cooperating classes that make up a reusable design solution for a given problem domain. The programmer uses a framework by inheriting the default behavior of the framework and overriding some of the behavior so that the framework calls application code, which is written by the programmer, at appropriate times (e.g., when a proprietary data structure is to be created or manipulated).
Incorporation of the principles of OOP and frameworks in a testing system for testing distributed environments allows the testing system to be more tightly integrated with other OOP-based applications and operating systems. In addition, the maintenance and development effort required by such an OOP-based testing systems will likely be significantly less than complex procedural programming-based testing systems. This is because parts (i.e., objects or classes) of the OOP-based testing system may be modified as needed and automatically propagated throughout the software code without affecting the rest of the testing system. In contrast, an entire procedural programming-based testing system, as conventionally produced, must be completely tested and debugged each time any modification is made to the software code, because each modification must be manually propagated to different parts of the software code. Therefore, there is a need for a method of testing distributed environments that incorporates the principles of OOP and frameworks.